Indeksisignaturet: Dynaamiset ominaisuustyyppimäärittelyt TypeScriptissä

Ohjelmistokehityksen jatkuvasti kehittyvässä maailmassa, erityisesti JavaScript-ekosysteemissä, joustavien ja dynaamisten tietorakenteiden tarve on ensiarvoisen tärkeää. TypeScript, vahvan tyyppijärjestelmänsä avulla, tarjoaa tehokkaita työkaluja monimutkaisuuden hallintaan ja koodin luotettavuuden varmistamiseen. Näistä työkaluista Indeksisignaturet erottuvat joukosta ratkaisevana ominaisuutena määritettäessä sellaisten ominaisuuksien tyyppejä, joiden nimiä ei tunneta etukäteen tai jotka voivat vaihdella merkittävästi. Tämä opas perehtyy syvällisesti indeksisignatureiden käsitteeseen tarjoten globaalin näkökulman niiden hyödyllisyyteen, toteutukseen ja parhaisiin käytäntöihin kehittäjille maailmanlaajuisesti.

Mitä ovat Indeksisignaturet?

Ytimeltään indeksisignature on tapa kertoa TypeScriptille objektin muodosta, jossa tiedät avainten (tai indeksien) tyypin ja arvojen tyypin, mutta et kaikkien avainten tarkkoja nimiä. Tämä on uskomattoman hyödyllistä käsiteltäessä dataa, joka tulee ulkoisista lähteistä, käyttäjän syötteestä tai dynaamisesti generoiduista konfiguraatioista.

Harkitse tilannetta, jossa haet konfiguraatiodataa kansainvälistetyn sovelluksen taustajärjestelmästä. Tämä data saattaa sisältää asetuksia eri kielille, joissa avaimet ovat kielikoodeja (kuten 'en', 'fr', 'es-MX') ja arvot ovat merkkijonoja, jotka sisältävät lokalisoidun tekstin. Et tiedä kaikkia mahdollisia kielikoodeja etukäteen, mutta tiedät, että ne ovat merkkijonoja, ja niihin liittyvät arvot ovat myös merkkijonoja.

Indeksisignatureiden Syntaksi

Indeksisignaturen syntaksi on suoraviivainen. Se sisältää indeksin (avaimen) tyypin määrittämisen hakasulkeissa, jota seuraa kaksoispiste ja arvon tyyppi. Tämä määritellään tyypillisesti interface- tai type alias -sisällä.

Tässä on yleinen syntaksi:

            
[keyName: KeyType]: ValueType;

            

              
                Copy
              
            
          

• keyName: Tämä on tunniste, joka edustaa indeksin nimeä. Se on käytäntö, eikä vaikuta tyypin tarkistukseen itsessään.
• KeyType: Tämä määrittää avainten tyypin. Yleisimmissä tapauksissa tämä on string tai number. Voit myös käyttää merkkijonoliteraalien yhdistetyyppejä, mutta tämä on harvinaisempaa ja usein paremmin hoidettu muilla keinoilla.
• ValueType: Tämä määrittää kunkin avaimen kanssa liitettyjen arvojen tyypin.

Yleisiä Käyttötapauksia Indeksisignatureille

Indeksisignaturet ovat erityisen arvokkaita seuraavissa tilanteissa:

• Konfiguraatio-objektit: Sovellusasetusten tallentaminen, joissa avaimet voivat edustaa ominaisuuslippuja, ympäristökohtaisia arvoja tai käyttäjän asetuksia. Esimerkiksi objekti, joka tallentaa teeman värejä, joissa avaimet ovat 'primary', 'secondary', 'accent' ja arvot ovat värikoodeja (merkkijonoja).
• Kansainvälistäminen (i18n) ja Lokalisointi (l10n): Eri kielten käännösten hallinta, kuten aiemmassa esimerkissä kuvattiin.
• API-vastaukset: Datan käsittely API:ista, joissa rakenne voi vaihdella tai sisältää dynaamisia kenttiä. Esimerkiksi vastaus, joka palauttaa luettelon kohteista, joissa jokainen kohde on avaimettu yksilöllisellä tunnisteella.
• Kartoitukset ja Sanakirjat: Yksinkertaisten avain-arvo-tallennustilojen tai sanakirjojen luominen, joissa sinun on varmistettava, että kaikki arvot ovat tietyn tyypin mukaisia.
• DOM-elementit ja Kirjastot: Vuorovaikutus JavaScript-ympäristöjen kanssa, joissa ominaisuuksia voidaan käyttää dynaamisesti, kuten elementtien käyttäminen kokoelmassa niiden ID:n tai nimen perusteella.

Indeksisignaturet string-avaimilla

Indeksisignatureiden yleisin käyttötapa on merkkijonoavainten kanssa. Tämä on täydellinen objekteille, jotka toimivat sanakirjoina tai karttoina.

Esimerkki 1: Käyttäjäasetukset

Kuvittele, että olet rakentamassa käyttäjäprofiilijärjestelmää, jonka avulla käyttäjät voivat asettaa mukautettuja asetuksia. Nämä asetukset voivat olla mitä tahansa, mutta haluat varmistaa, että mikä tahansa asetusarvo on joko merkkijono tai numero.

            
interface UserPreferences {
  [key: string]: string | number;
  theme: string;
  fontSize: number;
  notificationsEnabled: string; // Esimerkki merkkijonoarvosta
}

const myPreferences: UserPreferences = {
  theme: 'dark',
  fontSize: 16,
  notificationsEnabled: 'daily',
  language: 'en-US' // Tämä on sallittua, koska 'language' on merkkijonoavain ja 'en-US' on merkkijonoarvo.
};

console.log(myPreferences.theme); // Tuloste: dark
console.log(myPreferences['fontSize']); // Tuloste: 16
console.log(myPreferences.language); // Tuloste: en-US

// Tämä aiheuttaisi TypeScript-virheen, koska 'color' ei ole määritelty ja sen arvon tyyppi ei ole string | number:
// const invalidPreferences: UserPreferences = {
//   color: true;
// };

            

              
                Copy
              
            
          

Tässä esimerkissä [key: string]: string | number; määrittelee, että minkä tahansa ominaisuuden, johon päästään merkkijonoavaimella objektissa, jonka tyyppi on UserPreferences, on oltava arvo, joka on joko string tai number. Huomaa, että voit silti määrittää tiettyjä ominaisuuksia, kuten theme, fontSize ja notificationsEnabled. TypeScript tarkistaa, että nämä tietyt ominaisuudet myös noudattavat indeksisignaturen arvon tyyppiä.

Esimerkki 2: Kansainvälistetyt Viestit

Palataan kansainvälistämisen esimerkkiin. Oletetaan, että meillä on sanakirja viestejä eri kielille.

            
interface TranslatedMessages {
  [locale: string]: { [key: string]: string };
}

const messages: TranslatedMessages = {
  'en': {
    greeting: 'Hello',
    welcome: 'Welcome to our service',
  },
  'fr': {
    greeting: 'Bonjour',
    welcome: 'Bienvenue à notre service',
  },
  'es-MX': {
    greeting: 'Hola',
    welcome: 'Bienvenido a nuestro servicio',
  }
};

console.log(messages['en'].greeting); // Tuloste: Hello
console.log(messages['fr']['welcome']); // Tuloste: Bienvenue à notre service

// Tämä aiheuttaisi TypeScript-virheen, koska 'fr' ei ole ominaisuutta nimeltä 'farewell' määritelty:
// console.log(messages['fr'].farewell);

// Käsittelemään mahdollisesti puuttuvia käännöksiä sujuvasti, voit käyttää valinnaisia ominaisuuksia tai lisätä tarkempia tarkastuksia.

            

              
                Copy
              
            
          

Tässä ulompi indeksisignature [locale: string]: { [key: string]: string }; osoittaa, että messages-objektilla voi olla mikä tahansa määrä ominaisuuksia, joissa jokainen ominaisuusavain on merkkijono (joka edustaa aluetta, esim. 'en', 'fr'), ja kunkin tällaisen ominaisuuden arvo on itsessään objekti. Tällä sisemmällä objektilla, jonka määrittelee { [key: string]: string }-signature, voi olla mitä tahansa merkkijonoavaimia (jotka edustavat viestiavaimia, esim. 'greeting') ja niiden arvojen on oltava merkkijonoja.

Indeksisignaturet number-avaimilla

Indeksisignatureita voidaan käyttää myös numeeristen avainten kanssa. Tämä on erityisen hyödyllistä käsiteltäessä taulukoita tai taulukkomaisia rakenteita, joissa haluat pakottaa tietyn tyypin kaikille elementeille.

Esimerkki 3: Numerotaulukko

Vaikka taulukoilla TypeScriptissä on jo selkeä tyyppimäärittely (esim. number[]), saatat kohdata tilanteita, joissa sinun on edustettava jotain, joka käyttäytyy kuin taulukko, mutta on määritelty objektin kautta.

            
interface NumberCollection {
  [index: number]: number;
  length: number; // Taulukoilla on tyypillisesti length-ominaisuus
}

const numbers: NumberCollection = [
  10,
  20,
  30,
  40
];

numbers.length = 4; // Tämä on myös sallittua NumberCollection-rajapinnan mukaan

console.log(numbers[0]); // Tuloste: 10
console.log(numbers[2]); // Tuloste: 30

// Tämä aiheuttaisi TypeScript-virheen, koska arvo ei ole numero:
// numbers[1] = 'twenty';

            

              
                Copy
              
            
          

Tässä tapauksessa [index: number]: number; määrää, että minkä tahansa ominaisuuden, johon päästään numeerisella indeksillä numbers-objektissa, on tuotettava number. length-ominaisuus on myös yleinen lisäys mallinnettaessa taulukkomaisia rakenteita.

Esimerkki 4: Numeeristen ID:iden Kartoittaminen Dataan

Harkitse järjestelmää, jossa tietueisiin päästään numeeristen ID:iden perusteella.

            
interface RecordMap {
  [id: number]: { name: string, isActive: boolean };
}

const records: RecordMap = {
  101: { name: 'Alpha', isActive: true },
  205: { name: 'Beta', isActive: false },
  310: { name: 'Gamma', isActive: true }
};

console.log(records[101].name); // Tuloste: Alpha
console.log(records[205].isActive); // Tuloste: false

// Tämä aiheuttaisi TypeScript-virheen, koska ominaisuutta 'description' ei ole määritelty arvon tyypissä:
// console.log(records[101].description);

            

              
                Copy
              
            
          

Tämä indeksisignature varmistaa, että jos käytät ominaisuutta numeerisella avaimella records-objektissa, arvo on objekti, joka on muodon { name: string, isActive: boolean } mukainen.

Tärkeitä Huomioita ja Parhaita Käytäntöjä

Vaikka indeksisignaturet tarjoavat suurta joustavuutta, niihin liittyy myös joitain vivahteita ja mahdollisia sudenkuoppia. Näiden ymmärtäminen auttaa sinua käyttämään niitä tehokkaasti ja ylläpitämään tyyppiturvallisuutta.

1. Indeksisignaturen Tyyppirajoitukset

Avaintyyppi indeksisignaturessa voi olla:

• string
• number
• symbol (harvinaisempi, mutta tuettu)

Jos käytät number-tyyppiä indeksityyppinä, TypeScript muuntaa sen sisäisesti string-tyypiksi, kun ominaisuuksia käytetään JavaScriptissä. Tämä johtuu siitä, että JavaScript-objektiavaimet ovat pohjimmiltaan merkkijonoja (tai symboleja). Tämä tarkoittaa, että jos sinulla on sekä string- että number-indeksisignature samaan tyyppiin, string-signature on etusijalla.

Harkitse tätä:

            
interface MixedIndex {
  [key: string]: number;
  [index: number]: string; // Tämä ohitetaan tehokkaasti, koska merkkijonoindeksisignature kattaa jo numeeriset avaimet.
}

// Jos yrität määrittää arvoja:
const mixedExample: MixedIndex = {
  'a': 1,
  'b': 2
};

// Merkkijonosignaturen mukaan numeerisilla avaimilla pitäisi olla myös numeroarvoja.
mixedExample[1] = 3; // Tämä määritys on sallittu ja '3' määritetään.

// Kuitenkin, jos yrität käyttää sitä kuin numeroindeksisignature olisi aktiivinen arvotyypille 'string':
// console.log(mixedExample[1]); // Tämä tulostaa '3', numeron, ei merkkijonoa.

// mixedExample[1]:n tyyppi katsotaan 'number'-tyypiksi merkkijonoindeksisignaturen vuoksi.

            

              
                Copy
              
            
          

Paras Käytäntö: On yleensä parasta pitäytyä yhteen ensisijaiseen indeksisignaturetyyppiin (yleensä string) objektille, ellei sinulla ole hyvin erityistä syytä ja ymmärrät numeerisen indeksimuunnoksen vaikutuksia.

2. Vuorovaikutus Eksplisiittisten Ominaisuuksien Kanssa

Kun objektilla on indeksisignature ja myös eksplisiittisesti määritellyt ominaisuudet, TypeScript varmistaa, että sekä eksplisiittiset ominaisuudet että kaikki dynaamisesti käytetyt ominaisuudet ovat määritettyjen tyyppien mukaisia.

            
interface Config {
  port: number; // Eksplisiittinen ominaisuus
  [settingName: string]: any; // Indeksisignature sallii minkä tahansa tyypin muille asetuksille
}

const serverConfig: Config = {
  port: 8080,
  timeout: 5000,
  host: 'localhost',
  protocol: 'http'
};

// 'port' on numero, mikä on hyvä.
// 'timeout', 'host', 'protocol' ovat myös sallittuja, koska indeksisignature on 'any'.

// Jos indeksisignature olisi rajoittavampi:
interface StrictConfig {
  port: number;
  [settingName: string]: string | number;
}

const strictServerConfig: StrictConfig = {
  port: 8080,
  timeout: '5s', // Sallittu: merkkijono
  host: 'localhost' // Sallittu: merkkijono
};

// Tämä aiheuttaisi virheen:
// const invalidConfig: StrictConfig = {
//   port: 8080,
//   debugMode: true // Virhe: boolean ei ole määritettävissä tyypille string | number
// };

            

              
                Copy
              
            
          

Paras Käytäntö: Määritä eksplisiittiset ominaisuudet tunnetuille avaimille ja käytä indeksisignatureita tuntemattomille tai dynaamisille avaimille. Tee indeksisignaturen arvotyypistä mahdollisimman spesifinen tyyppiturvallisuuden ylläpitämiseksi.

3. any:n Käyttö Indeksisignatureiden Kanssa

Vaikka voit käyttää any-tyyppiä arvotyyppinä indeksisignaturessa (esim. [key: string]: any;), tämä pohjimmiltaan poistaa käytöstä tyypin tarkistuksen kaikille ominaisuuksille, joita ei ole määritelty eksplisiittisesti. Tämä voi olla nopea korjaus, mutta sitä tulisi välttää suosimalla tarkempia tyyppejä aina kun mahdollista.

            
interface AnyObject {
  [key: string]: any;
}

const data: AnyObject = {
  name: 'Example',
  value: 123,
  isActive: true,
  config: { setting: 'abc' }
};

console.log(data.name.toUpperCase()); // Toimii, mutta TypeScript ei voi taata, että 'name' on merkkijono.
console.log(data.value.toFixed(2)); // Toimii, mutta TypeScript ei voi taata, että 'value' on numero.

            

              
                Copy
              
            
          

Paras Käytäntö: Pyri mahdollisimman spesifiseen tyyppiin indeksisignaturen arvolle. Jos datallasi on todella heterogeenisia tyyppejä, harkitse yhdistetyypin (esim. string | number | boolean) tai erotellun yhdistetyypin käyttöä, jos on olemassa tapa erottaa tyypit.

4. Vain Lukemiseen Tarkoitettu Indeksisignaturet

Voit tehdä indeksisignatureista vain luettavia käyttämällä readonly-muokkainta. Tämä estää ominaisuuksien tahattoman muuttamisen objektin luomisen jälkeen.

            
interface ImmutableSettings {
  readonly [key: string]: string;
}

const settings: ImmutableSettings = {
  theme: 'dark',
  language: 'en',
  currency: 'USD'
};

console.log(settings.theme); // Tuloste: dark

// Tämä aiheuttaisi TypeScript-virheen:
// settings.theme = 'light';

// Voit silti määrittää eksplisiittisiä ominaisuuksia tietyillä tyypeillä, ja readonly-muokkain pätee myös niihin.
interface ReadonlyUser { 
  readonly id: number;
  readonly [key: string]: string;
}

const user: ReadonlyUser = {
  id: 123,
  username: 'global_dev',
  email: 'dev@example.com'
};

// user.id = 456; // Virhe
// user.username = 'new_user'; // Virhe

            

              
                Copy
              
            
          

Käyttötapaus: Ihanteellinen konfiguraatio-objekteille, joita ei pitäisi muuttaa suorituksen aikana, erityisesti globaaleissa sovelluksissa, joissa odottamattomia tilamuutoksia voi olla vaikea debugata eri ympäristöissä.

5. Päällekkäiset Indeksisignaturet

Kuten aiemmin mainittiin, useiden samantyyppisten indeksisignatureiden (esim. kaksi [key: string]: ...) käyttäminen ei ole sallittua ja johtaa käännösaikaiseen virheeseen.

Kuitenkin, kun käsitellään erilaisia indeksityyppejä (esim. string ja number), TypeScriptillä on erityisiä sääntöjä:

• Jos sinulla on indeksisignature tyypillä string ja toinen tyypillä number, string-signaturea käytetään kaikille ominaisuuksille. Tämä johtuu siitä, että numeeriset avaimet muunnetaan merkkijonoiksi JavaScriptissä.
• Jos sinulla on indeksisignature tyypillä number ja toinen tyypillä string, string-signature on etusijalla.

Tämä käyttäytyminen voi olla hämmennyksen lähde. Jos tarkoituksesi on saada erilaisia käyttäytymisiä merkkijono- ja numeroavaimille, sinun on usein käytettävä monimutkaisempia tyyppirakenteita tai yhdistetyyppejä.

6. Indeksisignaturet ja Metodimäärittelyt

Et voi määrittää metodeja suoraan indeksisignaturen arvotyypissä. Voit kuitenkin määrittää metodeja rajapinnoissa, joissa on myös indeksisignatureita.

            
interface DataProcessor {
  [key: string]: string; // Kaikkien dynaamisten ominaisuuksien on oltava merkkijonoja
  process(): void; // Metodi
  // Tämä olisi virhe: `processValue: (value: string) => string;` tulisi olla indeksisignaturetyypin mukainen.
}

const processor: DataProcessor = {
  data1: 'value1',
  data2: 'value2',
  process: () => {
    console.log('Processing data...');
  }
};

processor.process();
console.log(processor.data1);

// Tämä aiheuttaisi virheen, koska 'data3' ei ole merkkijono:
// processor.data3 = 123;

// Jos haluat, että metodit ovat osa dynaamisia ominaisuuksia, sinun on sisällytettävä ne indeksisignaturen arvotyyppiin:
interface DynamicObjectWithMethods {
  [key: string]: string | (() => void);
}

const dynamicObj: DynamicObjectWithMethods = {
  configValue: 'some_setting',
  runTask: () => console.log('Task executed!')
};

dynamicObj.runTask();
console.log(typeof dynamicObj.configValue);

            

              
                Copy
              
            
          

Paras Käytäntö: Erota selkeät metodit dynaamisista dataominaisuuksista paremman luettavuuden ja ylläpidettävyyden vuoksi. Jos metodeja on lisättävä dynaamisesti, varmista, että indeksisignature tukee asianmukaisia funktion tyyppejä.

Indeksisignatureiden Globaalit Sovellukset

Globaalissa kehitysympäristössä indeksisignaturet ovat korvaamattomia erilaisten datamuotojen ja vaatimusten käsittelyssä.

1. Kulttuurienvälinen Datan Käsittely

Skenaario: Globaalin verkkokauppa-alustan on näytettävä tuoteominaisuuksia, jotka vaihtelevat alueen tai tuoteryhmän mukaan. Esimerkiksi vaatteilla voi olla 'koko', 'väri', 'materiaali', kun taas elektroniikalla voi olla 'jännite', 'virrankulutus', 'liitettävyys'.

            
interface ProductAttributes {
  [attributeName: string]: string | number | boolean;
}

const clothingAttributes: ProductAttributes = {
  size: 'M',
  color: 'Blue',
  material: 'Cotton',
  isWashable: true
};

const electronicsAttributes: ProductAttributes = {
  voltage: 220,
  powerConsumption: '50W',
  connectivity: 'Wi-Fi, Bluetooth',
  hasWarranty: true
};

function displayAttributes(attributes: ProductAttributes) {
  for (const key in attributes) {
    console.log(`${key}: ${attributes[key]}`);
  }
}

displayAttributes(clothingAttributes);
displayAttributes(electronicsAttributes);

            

              
                Copy
              
            
          

Tässä ProductAttributes laajalla string | number | boolean -yhdistetyypillä mahdollistaa joustavuuden eri tuotetyyppien ja alueiden välillä, varmistaen, että mikä tahansa ominaisuusavain kartoittuu yhteiselle arvojoukolle.

2. Monivaluutta- ja Monikielituki

Skenaario: Taloussovelluksen on tallennettava valuuttakursseja tai hinnoittelutietoja useissa valuutoissa ja käyttäjälle näkyviä viestejä useilla kielillä. Nämä ovat klassisia käyttötapauksia sisäkkäisille indeksisignatureille.

            
interface ExchangeRates {
  [currencyCode: string]: number;
}

interface CurrencyData {
  base: string;
  rates: ExchangeRates;
}

interface LocalizedMessages {
  [locale: string]: { [messageKey: string]: string };
}

const usdData: CurrencyData = {
  base: 'USD',
  rates: {
    EUR: 0.93,
    GBP: 0.79,
    JPY: 157.38
  }
};

const frenchMessages: LocalizedMessages = {
  'fr': {
    welcome: 'Bienvenue',
    goodbye: 'Au revoir'
  }
};

console.log(`1 USD = ${usdData.rates.EUR} EUR`);
console.log(frenchMessages['fr'].welcome);

            

              
                Copy
              
            
          

Nämä rakenteet ovat välttämättömiä rakennettaessa sovelluksia, jotka palvelevat monipuolista kansainvälistä käyttäjäkuntaa, varmistaen, että data on oikein esitetty ja lokalisoitu.

3. Dynaamiset API-integraatiot

Skenaario: Integrointi kolmannen osapuolen API:ihin, jotka saattavat paljastaa kenttiä dynaamisesti. Esimerkiksi CRM-järjestelmä voi sallia mukautettujen kenttien lisäämisen kontaktitietoihin, joissa kenttien nimet ja niiden arvotyypit voivat vaihdella.

            
interface CustomContactFields {
  [fieldName: string]: string | number | boolean | null;
}

interface ContactRecord {
  id: number;
  name: string;
  email: string;
  customFields: CustomContactFields;
}

const user1: ContactRecord = {
  id: 1,
  name: 'Alice',
  email: 'alice@example.com',
  customFields: {
    leadSource: 'Webinar',
    accountTier: 2,
    isVIP: true,
    lastContacted: null
  }
};

function getCustomField(record: ContactRecord, fieldName: string): string | number | boolean | null {
  return record.customFields[fieldName];
}

console.log(`Lead Source: ${getCustomField(user1, 'leadSource')}`);
console.log(`Account Tier: ${getCustomField(user1, 'accountTier')}`);

            

              
                Copy
              
            
          

Tämä mahdollistaa ContactRecord-tyypin joustavuuden, jotta se voi mukautua laajaan valikoimaan mukautettuja tietoja ilman, että kaikkia mahdollisia kenttiä tarvitsee esimääritellä.

Johtopäätös

Indeksisignaturet TypeScriptissä ovat tehokas mekanismi sellaisten tyyppimäärittelyjen luomiseen, jotka tukevat dynaamisia ja arvaamattomia ominaisuuksien nimiä. Ne ovat perustavanlaatuisia rakennettaessa vankkoja, tyyppiturvallisia sovelluksia, jotka ovat vuorovaikutuksessa ulkoisen datan kanssa, käsittelevät kansainvälistämistä tai hallitsevat konfiguraatioita.

Ymmärtämällä, kuinka käyttää indeksisignatureita merkkijono- ja numeroavaimilla, ottamalla huomioon niiden vuorovaikutus eksplisiittisten ominaisuuksien kanssa ja soveltamalla parhaita käytäntöjä, kuten konkreettisten tyyppien määrittäminen any-tyypin sijaan ja hyödyntämällä readonly-muokkainta tarvittaessa, kehittäjät voivat parantaa merkittävästi TypeScript-koodikantojensa joustavuutta ja ylläpidettävyyttä.

Globaalissa kontekstissa, jossa tietorakenteet voivat olla uskomattoman monipuolisia, indeksisignaturet antavat kehittäjille mahdollisuuden rakentaa sovelluksia, jotka eivät ole vain joustavia, vaan myös mukautuvia kansainvälisen yleisön monipuolisiin tarpeisiin. Ota indeksisignaturet omaksesi ja avaa uusi dynaamisen tyypityksen taso TypeScript-projekteissasi.